﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Bansud.SGR.CommonSGR;
using System.Text.RegularExpressions;
using System.IO;
using System.Web;
using System.Collections;

namespace condortravel.operaciones.common
{
    public class UploadFileWebServer : IDisposable
    {
        private String rutaAplicativo;

        public String RutaAplicativo
        {
            get { return rutaAplicativo; }
            set { rutaAplicativo = value; }
        }
        private string m_NombreArchivo;
        private string m_RutaArchivo;
        private bool m_ValidarExtension = false;
        private bool m_ValidarPeso = false;
        private string m_DirDestino;
        private bool m_GenUniqueName;
        private string m_Carpeta = string.Empty;
        private bool m_ValidarExistencia = false;
        private string m_NombreOriginal;
        private string m_ExtensionArchivo;
        private double m_PesoArchivo;
        private long m_PesoMaximo = 1024 * 50 * 1024;
        //Private m_ExtensionesValidas As String = "^.+\.((gif)|(jpeg)|(jpg)|(zip)|(xls)|(doc)|(ppt)|(pdf)|(htm)|(html)|(txt)|(rar)|(mpp))$"

        private string m_ExtensionesValidas = "^.+\\.({0})$";
        public string Carpeta
        {
            get { return m_Carpeta; }
            set { m_Carpeta = value; }
        }
        public string ExtensionesValidas
        {
            get { return m_ExtensionesValidas; }
            set { m_ExtensionesValidas = value; }
        }

        public long PesoMaximo
        {
            get { return m_PesoMaximo; }
            set { m_PesoMaximo = value; }
        }

        public double PesoArchivo
        {
            get { return m_PesoArchivo / 1024; }
        }

        public string ExtensionArchivo
        {
            get { return m_ExtensionArchivo; }
        }

        public string NombreOriginal
        {
            get { return m_NombreOriginal; }
            set { m_NombreOriginal = value; }
        }

        public bool GenUniqueName
        {
            get { return m_GenUniqueName; }
            set { m_GenUniqueName = value; }
        }

        public bool ValidarExistencia
        {
            get { return m_ValidarExistencia; }
            set { m_ValidarExistencia = value; }
        }

        public bool ValidarPeso
        {
            get { return m_ValidarPeso; }
            set { m_ValidarPeso = value; }
        }

        public bool ValidarExtension
        {
            get { return m_ValidarExtension; }
            set { m_ValidarExtension = value; }
        }

        public string RutaArchivo
        {
            get { return m_RutaArchivo; }
            set { m_RutaArchivo = value; }
        }

        public string NombreArchivo
        {
            get { return m_NombreArchivo; }
            set { m_NombreArchivo = value; }
        }

        public string DirDestino
        {
            get { return m_DirDestino; }
            set { m_DirDestino = value; }
        }

        public bool ValidateExtension()
        {
            string checkFileregex = this.m_ExtensionesValidas;
            bool esValido = false;
            esValido = Regex.IsMatch(this.m_NombreArchivo, checkFileregex, RegexOptions.Multiline | RegexOptions.IgnoreCase);
            return esValido;
        }

        public bool ValidateExtension(string nombreArchivo)
        {
            string checkFileregex = this.m_ExtensionesValidas;
            bool esValido = false;
            esValido = Regex.IsMatch(this.m_NombreArchivo, checkFileregex, RegexOptions.Multiline | RegexOptions.IgnoreCase);
            return esValido;
        }

        public bool ValidateExtension(System.Web.UI.WebControls.FileUpload fileUp)
        {
            string checkFileregex = this.m_ExtensionesValidas;
            bool esValido = false;
            esValido = Regex.IsMatch(fileUp.PostedFile.FileName, checkFileregex, RegexOptions.Multiline | RegexOptions.IgnoreCase);
            return esValido;
        }

        public bool ValidatePeso(System.Web.UI.WebControls.FileUpload fileUp)
        {
            bool esValido = false;
            try
            {
                HttpPostedFile uploadFile = fileUp.PostedFile;
                Int64 intArchivoPeso = uploadFile.ContentLength;

                esValido = (intArchivoPeso > this.m_PesoMaximo ? false : true);
            }
            catch (Exception ex)
            {
                esValido = false;
                throw new Exception("Error al validar Peso de Archivo : " + ex.Message);
            }
            return esValido;
        }


        public void CargarArchivo(System.Web.UI.WebControls.FileUpload fileUp)
        {
            //if (this.m_ValidarExtension & !ValidateExtension(fileUp))
            //{
            //    //Throw New IOException("Extension no Valida")
            //    //Exit Sub
            //    throw new ExtensionNotValidException();
            //}

            if (this.m_ValidarPeso & !ValidatePeso(fileUp))
            {
                //Throw New IOException("Archivo muy Grande")
                //Exit Sub
                throw new BigFileException();
            }

            string UniqueName = (this.m_GenUniqueName ? System.Guid.NewGuid().ToString() : string.Empty);
            this.m_NombreOriginal = Path.GetFileName(fileUp.PostedFile.FileName);
            string NombreArchivoSave = string.Concat(UniqueName, this.m_NombreOriginal);



            //if (!string.IsNullOrEmpty(this.m_Carpeta))
            //{
            //    string NuevoDirectory = this.m_DirDestino + this.m_Carpeta;
            //    if (!Directory.Exists(NuevoDirectory))
            //    {
            //        Directory.CreateDirectory(NuevoDirectory);
            //    }
            //    this.m_DirDestino = NuevoDirectory + "\\";
            //}
            //string RutaCompleta = rutaAplicativo;
            //if (this.m_ValidarExistencia & ArchivoExiste(RutaCompleta))
            //{
            //    throw new FileExistException();
            //    //Throw New IOException("Archivo Existente")
            //    //Exit Sub
            //}
            String RutaCompleta = RutaAplicativo + "\\" + Carpeta+"\\" +NombreArchivoSave;
            fileUp.PostedFile.SaveAs(RutaCompleta);
            this.m_ExtensionArchivo = Path.GetExtension(RutaCompleta);
            this.m_NombreArchivo = NombreArchivoSave;
            this.m_PesoArchivo = fileUp.PostedFile.ContentLength;
            this.m_RutaArchivo = RutaCompleta;

        }

        public bool ArchivoExiste(string RutaArchivo)
        {
            bool esValido = false;
            try
            {
                FileInfo NuevoArchivo = new FileInfo(RutaArchivo);

                esValido = NuevoArchivo.Exists;
            }
            catch (Exception ex)
            {
                esValido = false;
                throw new Exception("Error al verificar la existencia del Archivo : " + ex.Message);
            }
            return esValido;
        }

        public bool ArchivoExiste()
        {
            bool esValido = false;
            try
            {
                FileInfo NuevoArchivo = new FileInfo(this.RutaArchivo);
                esValido = NuevoArchivo.Exists;
            }
            catch (Exception ex)
            {
                esValido = false;
                throw new Exception("Error al verificar la existencia del Archivo : " + ex.Message);
            }
            return esValido;
        }

        public void Delete(string RutaArchivo)
        {
            if (ArchivoExiste(RutaArchivo))
            {
                FileInfo _File = new FileInfo(RutaArchivo);
                _File.Delete();
            }

        }
        public void Move(string RutaOriginal, string RutaNueva)
        {
            //If Not String.IsNullOrEmpty(Me.m_Carpeta) Then
            string NuevoDirectory = this.m_DirDestino + this.m_Carpeta;
            if (!Directory.Exists(NuevoDirectory))
            {
                Directory.CreateDirectory(NuevoDirectory);
            }
            //Me.m_DirDestino = NuevoDirectory & "\"
            //End If

            if (ArchivoExiste(RutaOriginal))
            {
                System.IO.File.Move(RutaOriginal, RutaNueva);
            }
        }

        public UploadFileWebServer(bool ValidarExtension, bool ValidarPeso, bool ValidarExistencia)
        {
            this.ValidarPeso = ValidarPeso;
            this.ValidarExtension = ValidarExtension;
            this.ValidarExistencia = ValidarExistencia;
            //this.config();
        }

        //Seguridad
        private string serverUser;
        private string serverPassword;
        private string domainName;
        private string serverName;

        private string folderName;

        private Impersonate objImpersonate = new Impersonate();
        private void config()
        {
            try
            {
                HttpContext ctx = HttpContext.Current;

                string registry = ctx.Application["RegistroClave"].ToString();
                //HD
                Hashtable table = null;

                //table = condortravel.operaciones.common.Util.readConnectioRegedit((String)ctx.Application[AppStatic.CONNECTION_REGEDIT_FILESERVER]);
                if (table != null)
                {
                    this.serverName = table["ServerName"].ToString();
                    this.serverUser = table["ServerUser"].ToString();
                    this.serverPassword = table["ServerPassword"].ToString();
                    this.domainName = table["DomainName"].ToString();
                    this.folderName = table["FolderName"].ToString();


                    //HD
                    //string connectionString = SGRUtil.obtenerCadenaConexion(eCadenaConexion.Upload, false);
                    //LeeRegistro(registry, "CadenaConexionUpload")
                    //HD 20070305
                    string strarg = null;
                    //HD 20070305
                    //Hashtable configTable = SGRUtil.leerCadenaConexion(connectionString);

                    //HD 20070305

                    strarg = System.Configuration.ConfigurationSettings.AppSettings["ExtensionUpload"];

                    m_ExtensionesValidas = string.Format(m_ExtensionesValidas, strarg);
                }
                //HD 20070305
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }

        }


        public bool obtenerPermisos()
        {
            bool retornar = false;
            try
            {
                retornar = objImpersonate.impersonateValidUser(this.serverUser, this.domainName, this.serverPassword);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

            return retornar;
        }

        public void dejarPermisos()
        {
            try
            {
                this.objImpersonate.undoImpersonation();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        public string Folder
        {
            get { return string.Concat("\\\\", this.serverName, "\\", this.folderName, "\\"); }
        }

        public void CrearCarpeta(string carpeta)
        {
            string ruta = string.Concat(this.Folder, carpeta);
            try
            {
                if (!Directory.Exists(ruta))
                {
                    Directory.CreateDirectory(ruta);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message, ex);
            }
        }

        #region Implementation of IDisposable

        ~UploadFileWebServer()
        {
            Dispose(false);
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing,
        /// releasing, or resetting unmanaged resources.
        /// </summary>
        /// <filterpriority>2</filterpriority>
        public void Dispose()
        {
            Dispose(false);
        }

        private void Dispose(bool disposing)
        {
            if (disposing) GC.SuppressFinalize(this);
        }

        #endregion
    }

}
